பைதான் FastAPI இடைநிலை: கோரிக்கை மற்றும் மறுமொழி செயலாக்கத்திற்கான விரிவான வழிகாட்டி

நவீன வலை மேம்பாட்டு உலகில், செயல்திறன், பாதுகாப்பு மற்றும் பராமரிப்பு ஆகியவை மிக முக்கியமானவை. பைத்தானின் FastAPI கட்டமைப்பானது அதன் நம்பமுடியாத வேகம் மற்றும் டெவலப்பர்-நட்பு அம்சங்களுக்காக விரைவாக பிரபலமடைந்து வருகிறது. அதன் மிகவும் சக்திவாய்ந்த ஆனால் சில நேரங்களில் தவறாகப் புரிந்து கொள்ளப்பட்ட அம்சங்களில் ஒன்று இடைநிலை. இடைநிலை என்பது கோரிக்கை மற்றும் மறுமொழி செயலாக்கத்தில் ஒரு முக்கியமான இணைப்புச் சங்கிலியாக செயல்படுகிறது, இது டெவலப்பர்கள் குறியீட்டை இயக்கவும், தரவை மாற்றவும் மற்றும் ஒரு கோரிக்கை அதன் இலக்கை அடைவதற்கு முன்போ அல்லது ஒரு பதில் வாடிக்கையாளருக்கு அனுப்பப்படுவதற்கு முன்போ விதிகளை செயல்படுத்த அனுமதிக்கிறது.

இந்த விரிவான வழிகாட்டி FastAPI உடன் தொடங்குபவர்கள் முதல் தங்கள் புரிதலை ஆழப்படுத்த விரும்பும் அனுபவம் வாய்ந்த வல்லுநர்கள் வரையிலான டெவலப்பர்களின் உலகளாவிய பார்வையாளர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. இடைநிலையின் முக்கிய கருத்துகளை ஆராய்வோம், தனிப்பயன் தீர்வுகளை எவ்வாறு உருவாக்குவது என்பதைக் காண்பிப்போம், மேலும் நடைமுறை, உண்மையான பயன்பாட்டு நிகழ்வுகள் மூலம் நடக்கலாம். முடிவில், மேலும் வலுவான, பாதுகாப்பான மற்றும் திறமையான APIகளை உருவாக்க இடைநிலையைப் பயன்படுத்த உங்களுக்குத் தேவையான அனைத்தும் இருக்கும்.

வலை கட்டமைப்புகளின் சூழலில் இடைநிலை என்றால் என்ன?

குறியீட்டில் மூழ்குவதற்கு முன், கருத்தைப் புரிந்துகொள்வது அவசியம். உங்கள் பயன்பாட்டின் கோரிக்கை-பதில் சுழற்சியை ஒரு குழாய் அல்லது ஒரு அசெம்பிளி வரியாக கற்பனை செய்து பாருங்கள். ஒரு கிளையன்ட் உங்கள் APIக்கு ஒரு கோரிக்கையை அனுப்பும்போது, அது உடனடியாக உங்கள் எண்ட்பாயிண்ட் லாஜிக்கை தாக்குவதில்லை. மாறாக, இது தொடர்ச்சியான செயலாக்க படிகள் வழியாக பயணிக்கிறது. இதேபோல், உங்கள் எண்ட்பாயிண்ட் ஒரு பதிலை உருவாக்கும்போது, அது கிளையண்டை அடைவதற்கு முன்பு இந்த படிகள் வழியாக மீண்டும் பயணிக்கிறது. இடைநிலை கூறுகள் குழாயில் உள்ள இந்த படிகளாகும்.

பிரபலமான ஒப்புமை வெங்காய மாதிரி. வெங்காயத்தின் மையமானது உங்கள் பயன்பாட்டின் வணிக தர்க்கம் (எண்ட்பாயிண்ட்). மையத்தைச் சுற்றியுள்ள வெங்காயத்தின் ஒவ்வொரு அடுக்கையும் இடைநிலை ஆகும். ஒரு கோரிக்கை மையத்திற்குச் செல்ல ஒவ்வொரு வெளிப்புற அடுக்கையும் உரித்துச் செல்ல வேண்டும், மேலும் மறுமொழி அதே அடுக்குகளின் வழியாக மீண்டும் வெளியே பயணிக்கிறது. ஒவ்வொரு அடுக்கையும் உள்ளே செல்லும் வழியில் கோரிக்கையையும் வெளியே செல்லும் வழியில் பதிலையும் ஆய்வு செய்து மாற்றலாம்.

சுருக்கமாக, இடைநிலை என்பது ஒரு செயல்பாடு அல்லது வகுப்பாகும், இது கோரிக்கை பொருள், மறுமொழி பொருள் மற்றும் பயன்பாட்டின் கோரிக்கை-பதில் சுழற்சியில் உள்ள அடுத்த இடைநிலை ஆகியவற்றிற்கான அணுகலைக் கொண்டுள்ளது. இதன் முக்கிய நோக்கங்கள் பின்வருமாறு:

• குறியீட்டை இயக்குதல்: உள்வரும் ஒவ்வொரு கோரிக்கைக்கும் பதிவுகள் அல்லது செயல்திறன் கண்காணிப்பு போன்ற செயல்களைச் செய்யவும்.
• கோரிக்கை மற்றும் பதிலை மாற்றுதல்: தலைப்புகளைச் சேர்க்கவும், மறுமொழி உடல்களை சுருக்கவும் அல்லது தரவு வடிவங்களை மாற்றவும்.
• சுழற்சியை குறுக்குவழி செய்தல்: கோரிக்கை-பதில் சுழற்சியை முன்கூட்டியே முடிக்கவும். உதாரணமாக, அங்கீகார இடைநிலை அங்கீகரிக்கப்படாத கோரிக்கை इच्छित முடிவை எட்டுவதற்கு முன்பே அதைத் தடுக்கலாம்.
• உலகளாவிய கவலைகளை நிர்வகித்தல்: பிழை கையாளுதல், CORS (குறுக்கு மூல வள பகிர்வு) மற்றும் ஒரு மையப்படுத்தப்பட்ட இடத்தில் அமர்வு மேலாண்மை போன்ற குறுக்கு வெட்டு கவலைகளைக் கையாளவும்.

FastAPI ஆனது Starlette கருவித்தொகுப்பின் மேல் கட்டப்பட்டுள்ளது, இது ASGI (ஒத்திசைவற்ற சேவையக நுழைவாயில் இடைமுகம்) தரநிலையின் வலுவான செயலாக்கத்தை வழங்குகிறது. இடைநிலை என்பது ASGI இல் ஒரு அடிப்படை கருத்தாகும், இது FastAPI சூழலில் முதல் வகுப்பு குடிமகனாக ஆக்குகிறது.

எளிமையான வடிவம்: ஒரு டெக்கரேட்டருடன் FastAPI இடைநிலை

@app.middleware("http") டெக்கரேட்டரைப் பயன்படுத்தி இடைநிலையைச் சேர்க்க FastAPI ஒரு நேரடியான வழியை வழங்குகிறது. ஒவ்வொரு HTTP கோரிக்கைக்கும் இயக்க வேண்டிய எளிய, தன்னிறைவான தர்க்கத்திற்கு இது சரியானது.

ஒரு உன்னதமான உதாரணத்தை உருவாக்குவோம்: ஒவ்வொரு கோரிக்கைக்கும் செயலாக்க நேரத்தைக் கணக்கிட்டு அதை மறுமொழி தலைப்புகளில் சேர்க்க ஒரு இடைநிலை. இது செயல்திறன் கண்காணிப்புக்கு நம்பமுடியாத அளவிற்கு பயனுள்ளதாக இருக்கும்.

உதாரணம்: ஒரு செயல்முறை-நேர இடைநிலை

முதலில், உங்களிடம் FastAPI மற்றும் Uvicorn போன்ற ASGI சேவையகம் நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும்:

pip install fastapi uvicorn

இப்போது, main.py எனப்படும் கோப்பில் குறியீட்டை எழுதுவோம்:

import time

from fastapi import FastAPI, Request

app = FastAPI()

# இடைநிலை செயல்பாட்டை வரையறுக்கவும்

@app.middleware("http")

async def add_process_time_header(request: Request, call_next):

# கோரிக்கை வரும்போது தொடக்க நேரத்தைப் பதிவு செய்யவும்

start_time = time.time()

# அடுத்த இடைநிலை அல்லது எண்ட்பாயிண்டிற்கு தொடரவும்

response = await call_next(request)

# செயலாக்க நேரத்தை கணக்கிடுங்கள்

process_time = time.time() - start_time

# பதிலுக்கு தனிப்பயன் தலைப்பைச் சேர்க்கவும்

response.headers["X-Process-Time"] = str(process_time)

return response

@app.get("/")

async def root():

# சில வேலைகளை உருவகப்படுத்துங்கள்

time.sleep(0.5)

return {"message": "Hello, World!"}

இந்த பயன்பாட்டை இயக்க, கட்டளையைப் பயன்படுத்தவும்:

uvicorn main:app --reload

இப்போது, cURL போன்ற கருவி அல்லது Postman போன்ற API கிளையண்ட் பயன்படுத்தி http://127.0.0.1:8000 க்கு ஒரு கோரிக்கையை அனுப்பினால், பதிலில் ஒரு புதிய தலைப்பைக் காண்பீர்கள், X-Process-Time, தோராயமாக 0.5 வினாடிகள் மதிப்புடன்.

குறியீட்டை உருவாக்குதல்:

• @app.middleware("http"): இந்த டெக்கரேட்டர் எங்கள் செயல்பாட்டை HTTP இடைநிலையாக பதிவு செய்கிறது.
• async def add_process_time_header(request: Request, call_next):: இடைநிலை செயல்பாடு ஒத்திசைவற்றதாக இருக்க வேண்டும். இது உள்வரும் Request பொருள் மற்றும் ஒரு சிறப்பு செயல்பாட்டைப் பெறுகிறது, call_next.
• response = await call_next(request): இது மிகவும் முக்கியமான வரி. call_next கோரிக்கையை குழாயில் அடுத்த கட்டத்திற்கு அனுப்புகிறது (மற்ற இடைநிலை அல்லது உண்மையான பாதை செயல்பாடு). நீங்கள் இந்த அழைப்பை `await` செய்ய வேண்டும். முடிவு எண்ட்பாயிண்ட் மூலம் உருவாக்கப்பட்ட Response பொருள்.
• response.headers[...] = ...: எண்ட்பாயிண்டிலிருந்து பதில் பெறப்பட்ட பிறகு, அதை மாற்றலாம், இந்த விஷயத்தில், ஒரு தனிப்பயன் தலைப்பைச் சேர்ப்பதன் மூலம்.
• return response: இறுதியாக, மாற்றியமைக்கப்பட்ட பதில் கிளையண்டிற்கு அனுப்பப்பட திரும்பும்.

வகுப்புகளுடன் உங்கள் சொந்த தனிப்பயன் இடைநிலையை உருவாக்குதல்

டெக்கரேட்டர் அணுகுமுறை எளிமையானது என்றாலும், இது மிகவும் சிக்கலான சூழ்நிலைகளுக்கு கட்டுப்படுத்தும், குறிப்பாக உங்கள் இடைநிலைக்கு கட்டமைப்பு தேவைப்படும்போது அல்லது சில உள் நிலையை நிர்வகிக்க வேண்டும். இந்த சந்தர்ப்பங்களில், FastAPI (Starlette வழியாக) BaseHTTPMiddleware ஐப் பயன்படுத்தி வகுப்பு அடிப்படையிலான இடைநிலையை ஆதரிக்கிறது.

ஒரு வகுப்பு அடிப்படையிலான அணுகுமுறை சிறந்த கட்டமைப்பை வழங்குகிறது, அதன் கட்டமைப்பாளரில் சார்பு ஊசி அனுமதிக்கிறது, மேலும் பொதுவாக சிக்கலான தர்க்கத்திற்கு மிகவும் பராமரிக்கக்கூடியது. முக்கிய தர்க்கம் ஒத்திசைவற்ற dispatch முறையில் உள்ளது.

உதாரணம்: ஒரு வகுப்பு அடிப்படையிலான API விசை அங்கீகார இடைநிலை

எங்கள் API ஐ பாதுகாக்கும் ஒரு நடைமுறை இடைநிலையை உருவாக்குவோம். இது ஒரு குறிப்பிட்ட தலைப்பைப் பார்க்கும், X-API-Key, மற்றும் விசை இல்லை அல்லது தவறானது என்றால், அது உடனடியாக 403 Forbidden பிழை பதிலை வழங்கும். இது கோரிக்கையை "குறுக்குவழி" செய்வதற்கான ஒரு எடுத்துக்காட்டு.

main.py இல்:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint

from starlette.responses import Response

# சரியான API விசைகளின் பட்டியல். ஒரு உண்மையான பயன்பாட்டில், இது ஒரு தரவுத்தளம் அல்லது பாதுகாப்பான பெட்டகத்திலிருந்து வரும்.

VALID_API_KEYS = ["my-super-secret-key", "another-valid-key"]

class APIKeyMiddleware(BaseHTTPMiddleware):

async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:

api_key = request.headers.get("X-API-Key")

if api_key not in VALID_API_KEYS:

# கோரிக்கையை குறுக்குவழி செய்து ஒரு பிழை பதிலை வழங்கவும்

return JSONResponse(

status_code=403,

content={"detail": "Forbidden: Invalid or missing API Key"}

)

# விசை சரியானதாக இருந்தால், கோரிக்கையுடன் தொடரவும்

response = await call_next(request)

return response

app = FastAPI()

# பயன்பாட்டிற்கு இடைநிலையைச் சேர்க்கவும்

app.add_middleware(APIKeyMiddleware)

@app.get("/")

async def root():

return {"message": "Welcome to the secure zone!"}

இப்போது, இந்த பயன்பாட்டை இயக்கும்போது:

• X-API-Key தலைப்பு இல்லாமல் (அல்லது தவறான மதிப்புடன்) ஒரு கோரிக்கை 403 நிலைக் குறியீட்டையும் JSON பிழை செய்தியையும் பெறும்.
• X-API-Key: my-super-secret-key என்ற தலைப்புடன் ஒரு கோரிக்கை வெற்றி பெற்று 200 OK பதிலை பெறும்.

இந்த முறை மிகவும் சக்தி வாய்ந்தது. / இல் உள்ள எண்ட்பாயிண்ட் குறியீடு API விசை சரிபார்ப்பைப் பற்றி எதுவும் தெரிந்து கொள்ளத் தேவையில்லை; அந்த கவலை இடைநிலை அடுக்கில் முற்றிலும் பிரிக்கப்பட்டுள்ளது.

இடைநிலைக்கான பொதுவான மற்றும் சக்திவாய்ந்த பயன்பாட்டு நிகழ்வுகள்

குறுக்கு வெட்டு கவலைகளைக் கையாள்வதற்கு இடைநிலை சரியான கருவி. மிகவும் பொதுவான மற்றும் தாக்கத்தை ஏற்படுத்தும் சில பயன்பாட்டு நிகழ்வுகளை ஆராய்வோம்.

1. மையப்படுத்தப்பட்ட பதிவுகள்

உற்பத்தி பயன்பாடுகளுக்கு விரிவான பதிவுகள் பேச்சுவார்த்தைக்குட்பட்டவை அல்ல. ஒவ்வொரு கோரிக்கை மற்றும் அதன் தொடர்புடைய பதில் பற்றிய முக்கியமான தகவல்களை நீங்கள் பதிவு செய்யும் ஒரு புள்ளியை உருவாக்க இடைநிலை உங்களை அனுமதிக்கிறது.

உதாரண பதிவுகள் இடைநிலை:

import logging

from fastapi import FastAPI, Request

import time

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def logging_middleware(request: Request, call_next):

start_time = time.time()

# கோரிக்கை விவரங்களைப் பதிவு செய்யவும்

logger.info(f"உள்வரும் கோரிக்கை: {request.method} {request.url.path}")

response = await call_next(request)

process_time = time.time() - start_time

# பதில் விவரங்களைப் பதிவு செய்யவும்

logger.info(f"பதில் நிலை: {response.status_code} | செயல்முறை நேரம்: {process_time:.4f}s")

return response

இந்த இடைநிலை உள்வரும் வழியில் கோரிக்கை முறை மற்றும் பாதையையும், அதன் வெளியேறும் வழியில் பதில் நிலை குறியீடு மற்றும் மொத்த செயலாக்க நேரத்தையும் பதிவு செய்கிறது. இது உங்கள் பயன்பாட்டின் ட்ராஃபிக்கில் விலைமதிப்பற்ற தெரிவுநிலையை வழங்குகிறது.

2. உலகளாவிய பிழை கையாளுதல்

இயல்பாக, உங்கள் குறியீட்டில் கையாளப்படாத விதிவிலக்கு 500 உள் சேவையக பிழையில் விளைகிறது, இது குவியல் தடயங்களையும் செயல்பாட்டு விவரங்களையும் கிளையண்டிற்கு வெளிப்படுத்துகிறது. ஒரு உலகளாவிய பிழை கையாளுதல் இடைநிலை எல்லா விதிவிலக்குகளையும் பிடிக்கலாம், உள் மதிப்பாய்வுக்காக அவற்றைப் பதிவு செய்யலாம் மற்றும் தரப்படுத்தப்பட்ட, பயனர் நட்பு பிழை பதிலை வழங்கலாம்.

உதாரண பிழை கையாளுதல் இடைநிலை:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

import logging

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def error_handling_middleware(request: Request, call_next):

try:

return await call_next(request)

except Exception as e:

logger.error(f"கையாளப்படாத பிழை ஏற்பட்டது: {e}", exc_info=True)

return JSONResponse(

status_code=500,

content={"detail": "உள் சேவையக பிழை ஏற்பட்டது. பின்னர் மீண்டும் முயற்சிக்கவும்."}

)

@app.get("/error")

async def cause_error():

return 1 / 0 # இது ஜீரோ பிரிவுபிழையை எழுப்பும்

இந்த இடைநிலை இடத்தில், /error க்கான கோரிக்கை இனி சேவையகத்தை செயலிழக்கச் செய்யாது அல்லது குவியல் தடயத்தை வெளிப்படுத்தாது. அதற்கு பதிலாக, இது ஒரு சுத்தமான JSON உடலுடன் 500 நிலையான குறியீட்டை நேர்த்தியாக வழங்கும், அதே நேரத்தில் முழு பிழையும் டெவலப்பர்கள் விசாரிக்க சேவையக பக்கத்தில் பதிவு செய்யப்படும்.

3. CORS (குறுக்கு மூல வள பகிர்வு)

உங்கள் முன்முனை பயன்பாடு உங்கள் FastAPI பின்தளத்தை விட வேறு டொமைன், நெறிமுறை அல்லது போர்ட்டிலிருந்து வழங்கப்பட்டால், ஒரே மூல கொள்கையின் காரணமாக உலாவிகள் கோரிக்கைகளைத் தடுக்கும். இந்த கொள்கையை தளர்த்துவதற்கான வழிமுறை CORS ஆகும். FastAPI இந்த குறிப்பிட்ட நோக்கத்திற்காக அர்ப்பணிக்கப்பட்ட, மிகவும் கட்டமைக்கக்கூடிய `CORSMiddleware` ஐ வழங்குகிறது.

உதாரண CORS கட்டமைப்பு:

from fastapi import FastAPI

from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# அனுமதிக்கப்பட்ட தோற்றங்களின் பட்டியலை வரையறுக்கவும். பொது APIகளுக்கு "*" ஐப் பயன்படுத்தவும், ஆனால் சிறந்த பாதுகாப்புக்கு குறிப்பிட்டதாக இருங்கள்.

origins = [

"http://localhost:3000",

"https://my-production-frontend.com",

]

app.add_middleware(

CORSMiddleware,

allow_origins=origins,

allow_credentials=True, # குறுக்கு மூல கோரிக்கைகளில் குக்கீகளைச் சேர்க்க அனுமதிக்கவும்

allow_methods=["*"], # அனைத்து நிலையான HTTP முறைகளையும் அனுமதிக்கவும்

allow_headers=["*"], # அனைத்து தலைப்புகளையும் அனுமதிக்கவும்

)

இது பிரிக்கப்பட்ட முன்முனையுடன் எந்தவொரு திட்டத்திற்கும் நீங்கள் சேர்க்கும் முதல் இடைநிலை துண்டுகளில் ஒன்றாகும், இது ஒரு இடம், மைய இடத்திலிருந்து குறுக்கு மூல கொள்கைகளை நிர்வகிப்பதை எளிதாக்குகிறது.

4. GZip சுருக்கம்

HTTP பதில்களை சுருக்குவது அவற்றின் அளவை கணிசமாகக் குறைக்கலாம், இதன் விளைவாக கிளையண்டுகளுக்கு விரைவான ஏற்றுதல் நேரங்கள் மற்றும் குறைந்த அலைவரிசை செலவுகள் ஏற்படும். இதை தானாக கையாள FastAPI ஒரு `GZipMiddleware` ஐ உள்ளடக்கியது.

உதாரண GZip இடைநிலை:

from fastapi import FastAPI

from fastapi.middleware.gzip import GZipMiddleware

app = FastAPI()

# GZip இடைநிலையைச் சேர்க்கவும். சுருக்கத்திற்கு குறைந்தபட்ச அளவை நீங்கள் அமைக்கலாம்.

app.add_middleware(GZipMiddleware, minimum_size=1000)

@app.get("/")

async def root():

# இந்த பதில் சிறியது மற்றும் ஜிப் செய்யப்படாது.

return {"message": "Hello World"}

@app.get("/large-data")

async def large_data():

# இந்த பெரிய பதில் இடைநிலை மூலம் தானாகவே ஜிப் செய்யப்படும்.

return {"data": "a_very_long_string..." * 1000}

இந்த இடைநிலையுடன், கிளையன்ட் ஜிப் குறியாக்கத்தை ஏற்றுக்கொள்வதாகக் குறித்தால் 1000 பைட்டுகளுக்கு அதிகமான எந்த பதிலும் சுருக்கப்படும் (இது கிட்டத்தட்ட அனைத்து நவீன உலாவிகள் மற்றும் கிளையண்டுகளும் செய்கின்றன).

மேம்பட்ட கருத்துகள் மற்றும் சிறந்த நடைமுறைகள்

நீங்கள் இடைநிலையுடன் அதிக திறமையானவர்களாகும்போது, சுத்தமான, திறமையான மற்றும் கணிக்கக்கூடிய குறியீட்டை எழுத சில நுணுக்கங்களையும் சிறந்த நடைமுறைகளையும் புரிந்துகொள்வது அவசியம்.

1. இடைநிலை வரிசை முக்கியம்!

நினைவில் கொள்ள வேண்டிய மிக முக்கியமான விதி இது. பயன்பாட்டில் சேர்க்கப்படும் வரிசையில் இடைநிலை செயலாக்கப்படுகிறது. முதலில் சேர்க்கப்பட்ட இடைநிலை "வெங்காயத்தின்" வெளிப்புற அடுக்கு.

இந்த அமைப்பைக் கவனியுங்கள்:

app.add_middleware(ErrorHandlingMiddleware) # வெளிப்புறமானது

app.add_middleware(LoggingMiddleware)

app.add_middleware(AuthenticationMiddleware) # உள்நோக்கியது

ஒரு கோரிக்கையின் ஓட்டம்:

1. ErrorHandlingMiddleware கோரிக்கையைப் பெறுகிறது. இது ஒரு `try...except` தொகுதியில் அதன் `call_next` ஐ மடிக்கிறது.
2. இது `LoggingMiddleware` க்கு கோரிக்கையை கடந்து `next` ஐ அழைக்கிறது.
3. LoggingMiddleware கோரிக்கையைப் பெற்று, அதை பதிவுசெய்து, `next` ஐ அழைக்கிறது.
4. AuthenticationMiddleware கோரிக்கையைப் பெற்று, சான்றுகளை சரிபார்த்து, `next` ஐ அழைக்கிறது.
5. கோரிக்கை இறுதியாக எண்ட்பாயிண்டை அடைகிறது.
6. எண்ட்பாயிண்ட் ஒரு பதிலை அளிக்கிறது.
7. AuthenticationMiddleware பதிலைப் பெற்று அதைப் பின்னர் கடந்து செல்கிறது.
8. LoggingMiddleware பதிலைப் பெற்று, அதை பதிவுசெய்து, அதைப் பின்னர் கடந்து செல்கிறது.
9. ErrorHandlingMiddleware இறுதி பதிலை பெற்று அதை கிளையண்டிற்கு அனுப்புகிறது.

இந்த வரிசை தர்க்கரீதியானது: பிழை கையாளுபவர் வெளியே இருக்கிறார், எனவே அவர் மற்ற இடைநிலை உட்பட எந்தவொரு அடுத்தடுத்த அடுக்கிலிருந்தும் பிழைகளைப் பிடிக்க முடியும். அங்கீகார அடுக்கு ஆழமாக உள்ளே உள்ளது, எனவே நிராகரிக்கப்படப் போகும் கோரிக்கைகளை நாங்கள் பதிவு செய்யவோ அல்லது செயலாக்கவோ வேண்டாம்.

2. `request.state` உடன் தரவைக் கடத்தல்

சில நேரங்களில், ஒரு இடைநிலை எண்ட்பாயிண்டிற்கு தகவல்களை அனுப்ப வேண்டும். உதாரணமாக, அங்கீகார இடைநிலை ஒரு JWT ஐ டிகோட் செய்து பயனரின் ID ஐ பிரித்தெடுக்கலாம். இந்த பயனர் ஐடியை பாதை செயல்பாட்டு செயல்பாட்டிற்கு எவ்வாறு கிடைக்கச் செய்வது?

கோரிக்கை பொருளை நேரடியாக மாற்றுவது தவறான வழி. சரியான வழி `request.state` பொருளைப் பயன்படுத்துவதாகும். இது இந்த குறிப்பிட்ட நோக்கத்திற்காக வழங்கப்பட்ட எளிய, வெற்று பொருள்.

உதாரணம்: இடைநிலையிலிருந்து பயனர் தரவைக் கடத்தல்

# உங்கள் அங்கீகார இடைநிலையின் அனுப்பும் முறையில்:

# ... டோக்கனை சரிபார்த்து பயனரை டிகோட் செய்த பிறகு ...

user_data = {"id": 123, "username": "global_dev"}

request.state.user = user_data

response = await call_next(request)

# உங்கள் எண்ட்பாயிண்டில்:

@app.get("/profile")

async def get_user_profile(request: Request):

current_user = request.state.user

return {"profile_for": current_user}

இது தர்க்கத்தை சுத்தமாக வைத்திருக்கிறது மற்றும் `Request` பொருளின் பெயரை மாற்றுவதைத் தவிர்க்கிறது.

3. செயல்திறன் பரிசீலனைகள்

இடைநிலை சக்தி வாய்ந்ததாக இருந்தாலும், ஒவ்வொரு அடுக்கையும் ஒரு சிறிய அளவு மேல்நிலை சேர்க்கிறது. உயர் செயல்திறன் பயன்பாடுகளுக்கு, இந்த புள்ளிகளை மனதில் கொள்ளுங்கள்:

• அதை மெலிதாக வைத்திருங்கள்: இடைநிலை தர்க்கம் முடிந்தவரை வேகமாகவும் திறமையாகவும் இருக்க வேண்டும்.
• ஒத்திசைவற்றதாக இருங்கள்: உங்கள் இடைநிலைக்கு I/O செயல்பாடுகளைச் செய்ய வேண்டும் என்றால் (தரவுத்தள சோதனை போன்றவை), சேவையகத்தின் நிகழ்வு வளையத்தைத் தடுப்பதைத் தவிர்க்க இது முற்றிலும் `async` என்பதை உறுதிப்படுத்தவும்.
• நோக்கத்துடன் பயன்படுத்தவும்: உங்களுக்குத் தேவையில்லாத இடைநிலையைச் சேர்க்க வேண்டாம். ஒவ்வொன்றும் அழைப்பு குவியல் ஆழத்திற்கும் செயலாக்க நேரத்திற்கும் சேர்க்கிறது.

4. உங்கள் இடைநிலையை சோதனை செய்தல்

இடைநிலை என்பது உங்கள் பயன்பாட்டின் தர்க்கத்தின் ஒரு முக்கியமான பகுதியாகும், மேலும் அதை முழுமையாக சோதிக்க வேண்டும். FastAPI இன் `TestClient` இதை நேரடியானதாக்குகிறது. தேவையான நிபந்தனைகளுடன் மற்றும் இல்லாமல் கோரிக்கைகளை அனுப்பும் சோதனைகளை நீங்கள் எழுதலாம் (எ.கா., சரியான API விசையுடன் மற்றும் இல்லாமல்) மற்றும் இடைநிலை எதிர்பார்த்தபடி செயல்படுகிறதா என்பதை உறுதிப்படுத்தவும்.

APIKeyMiddleware க்கான உதாரண சோதனை:

from fastapi.testclient import TestClient

from .main import app # உங்கள் FastAPI பயன்பாட்டை இறக்குமதி செய்யவும்

client = TestClient(app)

def test_request_without_api_key_is_forbidden():

response = client.get("/")

assert response.status_code == 403

assert response.json() == {"detail": "Forbidden: Invalid or missing API Key"}

def test_request_with_valid_api_key_is_successful():

headers = {"X-API-Key": "my-super-secret-key"}

response = client.get("/", headers=headers)

assert response.status_code == 200

assert response.json() == {"message": "Welcome to the secure zone!"}

முடிவுரை

நவீன வலை APIகளை உருவாக்கும் எந்த டெவலப்பருக்கும் FastAPI இடைநிலை ஒரு அடிப்படை மற்றும் சக்திவாய்ந்த கருவியாகும். இது குறுக்கு வெட்டு கவலைகளைக் கையாள ஒரு நேர்த்தியான மற்றும் மீண்டும் பயன்படுத்தக்கூடிய வழியை வழங்குகிறது, அவற்றை உங்கள் முக்கிய வணிக தர்க்கத்திலிருந்து பிரிக்கிறது. ஒவ்வொரு கோரிக்கை மற்றும் பதிலையும் தடுத்து செயலாக்குவதன் மூலம், வலுவான பதிவுகள், மையப்படுத்தப்பட்ட பிழை கையாளுதல், கடுமையான பாதுகாப்பு கொள்கைகள் மற்றும் சுருக்கம் போன்ற செயல்திறன் மேம்பாடுகளை செயல்படுத்த இடைநிலை உங்களை அனுமதிக்கிறது.

எளிய @app.middleware("http") டெக்கரேட்டர் முதல் அதிநவீன, வகுப்பு அடிப்படையிலான தீர்வுகளுக்கு, உங்கள் தேவைகளுக்கு சரியான அணுகுமுறையைத் தேர்வுசெய்ய உங்களுக்கு நெகிழ்வுத்தன்மை உள்ளது. இடைநிலை வரிசை மற்றும் நிலை மேலாண்மை போன்ற முக்கிய கருத்துகள், பொதுவான பயன்பாட்டு வழக்குகள் மற்றும் சிறந்த நடைமுறைகளைப் புரிந்துகொள்வதன் மூலம், நீங்கள் சுத்தமான, பாதுகாப்பான மற்றும் மிகவும் பராமரிக்கக்கூடிய FastAPI பயன்பாடுகளை உருவாக்கலாம்.

இப்போது உங்கள் முறை. உங்கள் அடுத்த FastAPI திட்டத்தில் தனிப்பயன் இடைநிலையை ஒருங்கிணைக்கத் தொடங்குங்கள் மற்றும் உங்கள் API வடிவமைப்பில் புதிய அளவிலான கட்டுப்பாடு மற்றும் நேர்த்தியைத் திறக்கவும். சாத்தியக்கூறுகள் அதிகம், மேலும் இந்த அம்சத்தை மாஸ்டர் செய்வது நிச்சயமாக உங்களை மிகவும் பயனுள்ள மற்றும் திறமையான டெவலப்பராக மாற்றும்.